home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / neuron.zip / NEURON.C < prev    next >
C/C++ Source or Header  |  1992-07-06  |  34KB  |  925 lines
  1. /* Multilayers and/or interconnected network models             */
  2. /* Enable many networks study                                   */
  3. /* of auto-associated networks (Preceptron, Hopfield)           */
  4. /* Computation module                                           */
  5.  
  6. /* TC 2.0       NEURON.C        E.FARHI                         
  7.         versions: 0.0   09/91 experimental version 
  8.                   1.0   10/91 multi-layers network
  9.                   2.0   11/91 first version of a multi-model network
  10.                   2.1   01/92 adding learn_opt
  11.                   2.2   02/92 debugging, add noise
  12.                   2.3   03/92 debug, simulated tempering
  13.                   2.5   05/92 modifying learn_opt, add SHAKER
  14.                               learn_verify */
  15.                   
  16. /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  17. /*                      VERSION 2.5                             */
  18. /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
  19.                   
  20.                   
  21. /* ------------------------------------------------------------ */
  22. /* initialization beginning                                     */
  23. /* ------------------------------------------------------------ */
  24.  
  25.  
  26. /* Library uses                                                 */
  27.  
  28. #include <math.h>       /* for exp                              */
  29. #include <stdlib.h>     /* for random and malloc                */
  30. #include <time.h>       /* for network init on internal clock   */
  31. #include <stdio.h>      /* for printf(debugging)                */
  32.  
  33. /* Every printf can be removed for a tranparent use             */
  34.  
  35. /* Network Constants --------------------------------------     */
  36. /* internal use                                                 */
  37.  
  38. #define NB_LAYERS_MAXI  3       /* defines the maxi nb of different layers */
  39. #define NB_LEVELS_MAXI 3        /* defines the maxi nb of levels NB_LEV>=NB_LAY is better */
  40. #define NB_N_LAYER_MAXI 40      /* nb maxi of neurons in a layer*/
  41. #define NB_BACKP_MAXI   10      /* before shaker                */
  42. #define LEARN_FAIL      1000    /* test for learning failure    */
  43. #define MAX_RAND        32767.0
  44.  
  45. #define TEMPERING_OFF   0
  46. #define TEMPERING_ON    255     /* some different tempering modes */
  47.  
  48. #define MSG_NOISE       1       /* enables an external use      */
  49. #define MSG_STD         0
  50. #define MSG_ERR         255
  51.  
  52. /* Definition of 'networks' types ----------------------------- */
  53. /* You can add things if you wish                               */
  54.  
  55. typedef struct
  56.         {
  57.           char activity;                /* if neuron active     */
  58.         } FLAG_N;                       /* neuron flag  */
  59.  
  60. typedef struct
  61.         {
  62.           char interconnection  ;       /* if Hopfield layer    */        
  63.           char bias             ;       /* if 0, no bias        */
  64.         } FLAG_L;                       /* flag for layer       */
  65.         
  66. typedef struct
  67.         {
  68.           float intra[NB_N_LAYER_MAXI]; /* INTRA-layer weight, bi-directional link, Hopfield type */
  69.           float sum,                    /* weight sum           */
  70.                 state,                  /* neural state=f(sum)  */
  71.                 loc_err,                /* local weight error   */
  72.                 bias;                   /* neural bias  */
  73.           FLAG_N flag;                    
  74.         } NEURONS;                      /* formal neuron model          */
  75.  
  76. /* note :  high or low  state                           */
  77.         
  78.  
  79. typedef struct                          /* struct containing every infos for a network */
  80.         {
  81.           int nb_layers,                        /* nb of diferent layers in the net */
  82.               nb_n_layer[NB_LAYERS_MAXI],       /* neurons nb in a layer*/
  83.               nb_levels,                        /* levels nb in the network */
  84.               layer_order[NB_LEVELS_MAXI];      /* layer order          */
  85.                         /* some layers can be used for diferent levels */
  86.           FLAG_L flag[NB_LAYERS_MAXI];           
  87.           float err_threshold,                      /* for learning end        */
  88.                 coefficient,                    /* accentuate weight=links variations in the gradient */
  89.                 coef_out;                       /* output coefficient for continuum neuron */
  90.  
  91.           float beta,                           /* 1/thermo temperature   */
  92.                 high_threshold,                 /* potential thresholds for short mem */
  93.                 low_threshold,
  94.                 weight_threshold,               /* threshold for synaptic links */
  95.                 threshold,                      /* bascule threshold for learning and sigmoid */
  96.                 noise,                          /* noise for synaptic pot */
  97.                 high_state,                     /* state bounds for neurons */
  98.                 low_state;
  99.                 
  100.           unsigned char tempering;              /* simulated tempering */
  101.           float t_tempering_max,
  102.                 t_tempering_min,
  103.                 cte_tempering;
  104.           
  105.           float energy; 
  106.  
  107.           float inter[NB_LEVELS_MAXI][NB_N_LAYER_MAXI][NB_N_LAYER_MAXI];
  108.                /* INTER-levels coefs lev->lev+1 multi-perceptron */
  109.           
  110.           NEURONS neuron[NB_N_LAYER_MAXI][NB_LAYERS_MAXI];
  111.         } NETWORKS;     /* ISN'T IT BIG ? */
  112.                
  113. /* NOTE: layer = phisical neuron layer                  */
  114. /*       level = logical neuron layer                   */
  115.         
  116. /* local variables                                      */
  117.  
  118. char msg_prg=0;        /* global message */
  119.         
  120.  
  121. /* procedures declaration ------------------------------ */
  122.  
  123. /* NB : Have a look at the doc                           */
  124.  
  125. float sqr(float);
  126. float Rnd(float);
  127. float sigmoid(float,float,float);
  128. float sigmoid_derivative(float,float,float);
  129. int   *list_norm(int);
  130. int   *list_alea(int,int);
  131. float in_limits(float,float,float);
  132. int   equal(float,float);
  133.  
  134. float weight_sum(NETWORKS  *,int,int);          /* important */
  135. float level_state(NETWORKS  *,int);             /* important */
  136. float level_tempering(NETWORKS  *,int);
  137. float network_state(NETWORKS  *,float[]);
  138. float neuron_state(NETWORKS  *,float);
  139.  
  140. float backpropagation(NETWORKS  *,float[],float[]);     /* important */
  141. float learn_prototype(NETWORKS  *,int[],int,float[],float[],int);
  142. float learn_list(NETWORKS  *,int[],int,float[],float[]);
  143. int   learn_opt(NETWORKS  *,int[],int,float[],float[]); /* important */
  144. int   learn_norm(NETWORKS  *,int[],int,float[],float[]);
  145. int   learn_test(NETWORKS  *,int,long,long);
  146.  
  147. void  init_alea_network(NETWORKS  *);
  148. void  init_0_network(NETWORKS  *);
  149. void  init_flag_network(NETWORKS  *,int,int,int,int);
  150. void  init_var_network(NETWORKS  *,float,float,float,float,float,float,float,float,float,float,float,float,float,float);
  151.  
  152. float sqr_sum(NETWORKS  *);
  153. float compare_output(NETWORKS  *,float[]);
  154. float learn_verify(NETWORKS  *,int[],int,float[],float[]);
  155. void  print_network(NETWORKS  *);
  156. void  info_struct_network(NETWORKS  *);
  157. void  info_vars_network(NETWORKS  *);
  158.  
  159.  
  160.  
  161.  
  162. /* ------------------------------------------------------------ */
  163. /* procedures definition beginning                              */
  164. /* ------------------------------------------------------------ */
  165.  
  166.  
  167.  
  168. float sqr(float x)              /* mysterious procedure... */
  169. {
  170.   return(x*x);
  171. }
  172.  
  173. float Rnd(float x)              /* sends back a float between 0 and x */
  174. {
  175.   float rnd;
  176.   
  177.   rnd=(float)rand()/MAX_RAND*x;
  178.   return(rnd);
  179. }  
  180.  
  181. float sigmoid(float beta, float sum, float threshold)     /* sigmoid function */
  182. {                                        /* = transfert function */
  183.   int beta2=abs(beta);
  184.  
  185.   return(1/(1+exp(-2*beta2*(sum-threshold))));
  186. }                                       /* usually threshold=0   */
  187.  
  188. float sigmoid_derivative(float beta, float sum, float threshold)
  189. {                                       /* just guess */
  190.   float s;
  191.   s=sigmoid(beta,sum,threshold);
  192.   return(s*(1-s));
  193. }
  194.  
  195. /* procedures for defining a learning pedagogy  */
  196.  
  197. int *list_alea(size_line,nb_prototypes)     /* generate a random list to learn */
  198. int size_line;
  199. int nb_prototypes;
  200. {
  201.   int *list;
  202.   int i;
  203.   
  204.   list=malloc((size_line+1)*sizeof(int));
  205.   for (i=0; i<=size_line; i++)
  206.     list[i]=(int)(rand()*(nb_prototypes+1)/32768.0);
  207.   return(list);
  208. }
  209.  
  210. int *list_norm(nb_prototypes)                /* genarate the normal list */
  211. int nb_prototypes;
  212. { 
  213.   int *list;
  214.   int i;
  215.   
  216.   list=malloc((nb_prototypes+1)*sizeof(int));
  217.   for (i=0; i<=nb_prototypes; i++)
  218.     list[i]=i;
  219.   return(list);
  220. }
  221.  
  222. float in_limits(float x, float high, float low) /* to remain between bounds */
  223. {
  224.   float tmp=x;
  225.  
  226.   if (tmp>high) tmp=high;
  227.   else
  228.     if (tmp<low) tmp=low;
  229. /*  if (x != tmp)
  230.     printf("\a");*/
  231.   return (tmp);  
  232. }    
  233.  
  234. int equal(float var,float ref)  /* equal to within 1 % */
  235. {
  236.   return ((var<ref*1.01) && (var>0.99*ref));
  237. }  
  238.  
  239.  
  240. /* ------------------------------------------------------------ */
  241. /*              network state procedures                        */
  242. /* ------------------------------------------------------------ */
  243.  
  244.  
  245. float weight_sum(NETWORKS  *network,int neuron,int level)
  246. {                       /* weight sum of a neuron in a level */
  247.   int n,c,c_1;
  248.   float b,s=0;
  249.  
  250.   c=(*network).layer_order[level];            /* layer of a level */
  251.   if ((*network).neuron[neuron][c].flag.activity)       /* activee neuron ? */
  252.   {
  253.     s=(*network).neuron[neuron][c].bias;
  254.     if ((*network).flag[c].interconnection)      /* Hopfield ? */
  255.       for (n=0; n<=(*network).nb_n_layer[c]; n++)       /* INTRA-layer Hopfield sum */
  256.         s+=(*network).neuron[n][c].state*(*network).neuron[neuron][c].intra[n];
  257.     if (level >= 1)                            /* not the input layer */
  258.     {
  259.       c_1=(*network).layer_order[level-1];    /* preceding level */
  260.       for (n=0; n<=(*network).nb_n_layer[c_1]; n++)
  261.                                                 /* INTER-level perceptron sum */
  262.         s+=(*network).neuron[n][c_1].state*(*network).inter[level-1][n][neuron];
  263.     }           /* sends back s=0 if  inactiv or Perceptron input */
  264.   }
  265.   b=Rnd(2*(*network).noise)-(*network).noise;   /* add some noise */
  266.   if (s==0)
  267.     s=b/(*network).beta;
  268.   else
  269.     s*=1+b;
  270.   s=in_limits(s,(*network).high_threshold,(*network).low_threshold);
  271.  
  272.   return (s);
  273. }
  274.  
  275. float neuron_state(NETWORKS  *network,float s)
  276. {       /* for computing neural state */
  277.   float proba,state;
  278.  
  279.   proba=sigmoid((*network).beta,s,(*network).threshold);
  280.   if ((*network).beta<0)
  281.   {     /* stochastic neuron */
  282.     if (Rnd(1)<proba)
  283.       state=(*network).high_state;
  284.     else
  285.       state=(*network).low_state;
  286.   }    
  287.   else  /* continuum neuron */
  288.     state=((*network).high_state-(*network).low_state)*proba+(*network).low_state;      /* state continu entre -1 et 1 */
  289.   return(state);
  290. }
  291.  
  292. /* if T<0 it is a stochastic neuron                     */
  293. /* if T -> 0 the neuron becomes determinist             */
  294.    
  295. float level_state(NETWORKS  *network,int level)
  296. {       /* compute the state of a logic layer */
  297.   int layer,neuron;
  298.   float s,state2,
  299.         energy=0;                     /* level energy */
  300.   float state[NB_N_LAYER_MAXI][NB_LAYERS_MAXI];      
  301.  
  302.   layer=(*network).layer_order[level];
  303.   for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  304.   {
  305.     s=weight_sum(network,neuron,level);   /* synaptic potential */
  306.     state2=neuron_state(network,s);
  307.     state[neuron][layer]=state2;
  308.     if (level != 0)
  309.     {
  310.       energy+=state2*s;         /* energy=sum(i<>j)[-.5*Jij.Etat(i).Etat(j) ] */
  311.       (*network).neuron[neuron][layer].sum=s;   /* saving results, parallel calculation  */
  312.     }  
  313.  
  314.   }
  315.   if ((level>0) || ((*network).flag[layer].interconnection))
  316.         /* input unmodified exept for Hopfield */
  317.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  318.                                 /* network=network0 */
  319.       (*network).neuron[neuron][layer].state=state[neuron][layer];
  320.        
  321.   return(-0.5*energy);
  322. }
  323.  
  324.         
  325. float network_state(NETWORKS  *network,float input[])
  326. {       /* network state */
  327.   int neuron,
  328.       layer,
  329.       level;
  330.   float energy=0;    
  331.   
  332.   layer=(*network).layer_order[0];    
  333.   for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  334.     (*network).neuron[neuron][layer].state=input[neuron];
  335.                                 /* imposing an input */
  336.   for (level=0; level<=(*network).nb_levels; level++)
  337.     energy+=level_state(network,level);
  338.                                 /* progressing towards output  */
  339.   (*network).energy=energy;
  340.   return(energy);       /* network energy */
  341. }
  342.  
  343. /* ------------------------------------------------------------ */
  344. /*                      learning procedures                     */
  345. /* ------------------------------------------------------------ */
  346.  
  347. float backpropagation(NETWORKS  *network,float input[],float output[])     /* procedure d'apprentissage simple */
  348. {       /* gradient backpropagation algorithm */
  349.   int neuron,
  350.       layer,
  351.       layer1,           /* next layer           */
  352.       layer_1,          /* preceding layer      */
  353.       level,
  354.       n;
  355.   float error,
  356.         var,
  357.         err_tot=0;              /* global network error */      
  358.         
  359.   network_state(network,input);  
  360.   for (level = (*network).nb_levels; level >= 0; level--)
  361.   {                             /* progressing towards input */
  362.     layer=(*network).layer_order[level];
  363.     if (level > 0)                      /* except input */
  364.       layer_1=(*network).layer_order[level-1];
  365.     if (level < (*network).nb_levels)   /* except output */
  366.       layer1=(*network).layer_order[level+1];
  367.  
  368.     /*                  error caculation                */
  369.  
  370.     for (neuron = 0; neuron <= (*network).nb_n_layer[layer]; neuron++)
  371.     {
  372.       error=0;
  373.       if (level < (*network).nb_levels)
  374.       {                         /* error coming from the next layer */
  375.         for (n = 0; n <= (*network).nb_n_layer[layer1]; n++)
  376.                         /* on next layer : inter layer Perceptron */
  377.           error+=(*network).neuron[n][layer1].loc_err*(*network).inter[level][neuron][n];
  378.       } 
  379.       else
  380.       {                         /* output layer */
  381.         error=(*network).neuron[neuron][layer].state-output[neuron];
  382.         err_tot+=0.5*error*error;
  383.       }                         /* rough error */
  384.  
  385.       error*=sigmoid_derivative((*network).beta,(*network).neuron[neuron][layer].sum,(*network).threshold);
  386.       (*network).neuron[neuron][layer].loc_err=error;   /* local partial error (non Hopfield) */
  387.     }
  388.         
  389.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  390.     {
  391.       error=(*network).neuron[neuron][layer].loc_err;
  392.       if ((*network).flag[layer].interconnection)
  393.       {
  394.         var=sigmoid_derivative((*network).beta,(*network).neuron[neuron][layer].sum,(*network).threshold);
  395.         for (n=0; n<=(*network).nb_n_layer[layer]; n++)
  396.           error+=(*network).neuron[n][layer].loc_err*(*network).neuron[neuron][layer].intra[n]*var;  
  397.         (*network).neuron[neuron][layer].loc_err=error; /* local error  */
  398.       }
  399.  
  400.         /*              modifying weights                       */
  401.  
  402.       error*=-(*network).coefficient;   /* accentuates the weight variation */
  403.       if ((*network).flag[layer].bias) 
  404.                                 /* else bias remains at 0 */
  405.       {                          
  406.         var=(*network).neuron[neuron][layer].bias+error;
  407.         (*network).neuron[neuron][layer].bias=in_limits(var,(*network).weight_threshold,-(*network).weight_threshold);
  408.       }    
  409.       
  410.       if ((*network).flag[layer].interconnection)
  411.         for (n=0; n<=(*network).nb_n_layer[layer]; n++)
  412.                                 /* var intra weight */
  413.         {  
  414.           var=(*network).neuron[neuron][layer].intra[n]+error*(*network).neuron[n][layer].state;
  415.           (*network).neuron[neuron][layer].intra[n]=in_limits(var,(*network).weight_threshold,-(*network).weight_threshold);
  416.         }
  417.       if (level > 0)
  418.         for (n=0; n<=(*network).nb_n_layer[layer_1]; n++)
  419.                                 /* var inter weight */
  420.         {  
  421.           var=(*network).inter[level-1][n][neuron]+error*(*network).neuron[n][layer_1].state;
  422.           (*network).inter[level-1][n][neuron]=in_limits(var,(*network).weight_threshold,-(*network).weight_threshold);
  423.         }
  424.     }
  425.   }
  426.   return(err_tot);
  427. }
  428.  
  429. float learn_prototype(NETWORKS  *network,int list_prototypes[],int k,float inputs[],float outputs[],int nb_proto)
  430. {       /* learns a prototype to the net nb_proto times */
  431.   int j,NCin,NCout,nb_back=0,noise=0;
  432.   float err_tot,t,t0;           /* output error */
  433.   float input[NB_N_LAYER_MAXI],
  434.         output[NB_N_LAYER_MAXI];
  435.  
  436.                 /* neurons nb in 1st and last level */          
  437.   NCin=(*network).nb_n_layer[(*network).layer_order[0]];
  438.   NCout=(*network).nb_n_layer[(*network).layer_order[(*network).nb_levels]];
  439.  
  440.   for (j=0; j<=NCin; j++)       /* extract first prototype=(input,output) */
  441.   input[j]=inputs[list_prototypes[k]*(NCin+1)+j];  
  442.   for (j=0; j<=NCout; j++)
  443.   output[j]=outputs[list_prototypes[k]*(NCout+1)+j];
  444.  
  445.   t0=1/(*network).beta;
  446.   if (msg_prg==MSG_NOISE)
  447.   {
  448.     printf(" with SHAKER ");
  449.     noise=(*network).noise;
  450.     (*network).noise*=2;        /* noise */
  451.     msg_prg=MSG_STD;
  452.   }
  453.     
  454.   do
  455.   {             /* possibly simulated tempering */
  456.     t=-1;
  457.     if ((noise>0) && ((*network).tempering != TEMPERING_OFF))   /* thermic noise */
  458.     {
  459.       t=(*network).t_tempering_min+(*network).t_tempering_max*exp(-(float)nb_back/(*network).cte_tempering);
  460.       printf(".");
  461.     }  
  462.     if (t<t0) t=t0;
  463.     nb_back++;
  464.     err_tot=backpropagation(network,input,output);
  465.   }  
  466.   while (nb_back<nb_proto);
  467.   (*network).beta=1/t0;
  468.   return(err_tot);              /* sends back prototype error */
  469. }
  470.  
  471. float learn_list(NETWORKS  *network,int list_prototypes[],int size_list,float inputs[],float outputs[])       /* supervising learning */
  472.  
  473. /* int list_prototypes[];       prototype order to learn */
  474. /* int size_list;               prototypes nb in list */
  475. /* float inputs[],outputs[];    prototypes to learn */
  476.  
  477. {
  478.   int k;
  479.   float err_cumul=0;                    /* error sobre todos los prototypes */
  480.  
  481.   for (k=0; k<=size_list; k++)         /* let's read the list */
  482.     err_cumul+=learn_prototype(network,list_prototypes,k,inputs,outputs,1);
  483.   return(err_cumul/(size_list+1));
  484.                 /* sends back the mean prototype error */
  485. }
  486.  
  487.  
  488. int learn_opt(NETWORKS  *network,int list_prototypes[],int size_list,float inputs[],float outputs[])        /* learn en favorisant les prototypes mal connus */
  489. {       /* we need the normal list *list_norm(..)={1,2,..,n}      */
  490.         /* optimized learning                                   */
  491.   int k,i=0;
  492.   float error_mean,
  493.         error_m,error_m0,
  494.         err_max,err_max0,
  495.         error,
  496.         noise=(*network).noise;
  497.   int *priority_proto;
  498.  
  499.   priority_proto=(int *)malloc((size_t)sizeof(int)*(size_list+1));
  500.   error_mean=(*network).err_threshold*4;
  501.   error_m0=0;
  502.   err_max0=0;
  503.   for (k=0; k<=size_list; k++)  /* init learning priority */
  504.     priority_proto[k]=1;
  505.   do
  506.   {
  507.     error_m=0;
  508.     err_max=0;
  509.     printf("\nI learn all prototypes especially those I don't know well.\n");
  510.     for (k=0; k<=size_list; k++)       /* looking for the unknown prototype and error max */
  511.     {
  512.       error=learn_prototype(network,list_prototypes,k,inputs,outputs,priority_proto[k]);
  513.       error_m+=error;
  514.       if (err_max<error) err_max=error;
  515.       i+=priority_proto[k];
  516.       printf("\nPrototype No: %3i. Priority %3i. Error: %5.2f. Energy %4.1f.",k,priority_proto[k],error,(*network).energy);
  517.       if (error>=error_mean*1.05)
  518.         if (priority_proto[k]<NB_BACKP_MAXI)
  519.           priority_proto[k]++;
  520.         else
  521.         {
  522.           msg_prg=MSG_NOISE;  
  523.           priority_proto[k]/=2;
  524.         }  
  525.       else 
  526.         if ((error<=error_mean*.95) && (priority_proto[k]>1))
  527.           priority_proto[k]--;
  528.     }
  529.     error_mean=error_m/(size_list+1);
  530.     printf("\nTurn: %3i. Mean error %5.2f. Max error %5.2f.",i,error_mean,err_max);
  531.     if ((equal(error_m,error_m0)) && (equal(err_max,err_max0)))
  532.     {
  533.       (*network).noise*=2;
  534.       printf("\nGlobal Shaker");
  535.     }
  536.     else
  537.     {
  538.       error_m0=error_m;
  539.       err_max0=err_max;
  540.       (*network).noise=noise;
  541.     }
  542.   }
  543.   while ((err_max>=(*network).err_threshold) && (i<=LEARN_FAIL));
  544.   if (i==LEARN_FAIL) i*=-1;
  545.   return (i);   /* sends back the number of learning turns */
  546. }
  547.  
  548. int learn_norm(NETWORKS  *network,int list_lots[],int size_list,float inputs[],float outputs[])
  549. {       /* learn a prototype list */
  550.   int n=0;
  551.   float err;
  552.  
  553.   do
  554.   {
  555.     err=learn_list(network,list_lots,size_list,inputs,outputs);
  556.     printf("\nError: %4.3f",err);
  557.     n++;
  558.   }
  559.   while (err>(*network).err_threshold);
  560.   return (n);
  561. }
  562.  
  563. int learn_test(NETWORKS  *network,int nb_prototypes,long sizein,long sizeout)
  564. {               /* test the validity of prototypes */
  565.   int flag=1;
  566.   
  567.   if (((*network).nb_n_layer[(*network).layer_order[0]]*(nb_prototypes+1)>(sizein/sizeof(float)))
  568.   || ((*network).nb_n_layer[(*network).layer_order[(*network).nb_levels]]*(nb_prototypes+1)>(sizeout/sizeof(float))))
  569.     flag=0;
  570.   
  571.   return(flag);
  572. }
  573.  
  574. /* ------------------------------------------------------------ */
  575. /*              Initialization of networks                      */
  576. /* ------------------------------------------------------------ */    
  577.  
  578.   
  579.  
  580. void init_alea_network(NETWORKS  *network)
  581. {             /* initialize a random network */
  582.   int neuron,
  583.       layer,
  584.       level,
  585.       n,
  586.       lay_sup,nb_lev,nb_neuron,nb_neuron_sup;
  587.   float s; 
  588.            
  589.   srand((unsigned)clock());     /* used because it is portable */
  590.                 /* initialize random generator with the clock */
  591.   for (layer=0; layer<=(*network).nb_layers; layer++)
  592.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  593.     {
  594.       if ((*network).flag[layer].bias) 
  595.         (*network).neuron[neuron][layer].bias=Rnd(0.5)-0.25;
  596.       else
  597.         (*network).neuron[neuron][layer].bias=0;
  598.       s=Rnd(4)-2;
  599.       (*network).neuron[neuron][layer].sum=s;
  600.       (*network).neuron[neuron][layer].state=neuron_state(network,s);
  601.       (*network).neuron[neuron][layer].loc_err=0;
  602.        
  603.       for (n=0; n<=(*network).nb_n_layer[layer]; n++)
  604.         if ((*network).flag[layer].interconnection)
  605.           (*network).neuron[neuron][layer].intra[n]=Rnd(0.5)-0.25;
  606.         else
  607.           (*network).neuron[neuron][layer].intra[n]=0;
  608.     }
  609.   nb_lev=(*network).nb_levels-1;                /* nb of levels except the last */   
  610.   for (level=0; level<=nb_lev; level++)
  611.     {
  612.     layer=(*network).layer_order[level];        /* layer No level */
  613.     nb_neuron=(*network).nb_n_layer[layer];     /* nb of neuron in the level */
  614.     lay_sup=(*network).layer_order[level+1];    /* next level */
  615.     nb_neuron_sup=(*network).nb_n_layer[lay_sup];/* nb of neuron in lay_sup */
  616.     for (neuron=0; neuron<=nb_neuron;neuron++)
  617.       for (n=0; n<=nb_neuron_sup; n++)
  618.         (*network).inter[level][neuron][n]=Rnd(0.5)-0.25;
  619.     }
  620. }
  621.  
  622. void init_0_network(NETWORKS  *network)
  623.                 /* initializes a zero network */
  624. {
  625.   int neuron,
  626.       layer,
  627.       level,
  628.       n,
  629.       lay_sup,nb_lev,nb_neuron,nb_neuron_sup;
  630.            
  631.   for (layer=0; layer<=(*network).nb_layers; layer++)
  632.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  633.     {
  634.       (*network).neuron[neuron][layer].sum=0;
  635.       (*network).neuron[neuron][layer].state=0;
  636.       (*network).neuron[neuron][layer].loc_err=0;
  637.        
  638.       for (n=0; n<=(*network).nb_n_layer[layer]; n++)
  639.         (*network).neuron[neuron][layer].intra[n]=0;
  640.     }
  641.   nb_lev=(*network).nb_levels-1;                /* nb of levels except the last */   
  642.   for (level=0; level<=nb_lev; level++)
  643.     {
  644.     layer=(*network).layer_order[level];        /* layer No level */
  645.     nb_neuron=(*network).nb_n_layer[layer];     /* nb of neuron in level */
  646.     lay_sup=(*network).layer_order[level+1];    /* next level */
  647.     nb_neuron_sup=(*network).nb_n_layer[lay_sup];
  648.     for (neuron=0; neuron<=nb_neuron;neuron++)
  649.       for (n=0; n<=nb_neuron_sup; n++)
  650.         (*network).inter[level][neuron][n]=0;
  651.     }
  652. }
  653.  
  654.  
  655. void init_flag_network(NETWORKS  *network,int activity,int interconnection,int bias,int tempering)
  656.                 /* initializes flags for a net */
  657. {
  658.   int neuron,
  659.       layer;
  660.             
  661.   (*network).tempering=tempering;
  662.   for (layer=0; layer<=(*network).nb_layers; layer++)
  663.   {
  664.     (*network).flag[layer].interconnection=interconnection;
  665.     (*network).flag[layer].bias=bias;
  666.   }
  667.     
  668.   for (layer=0; layer<=(*network).nb_layers; layer++)  
  669.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  670.     {
  671.  
  672.       (*network).neuron[neuron][layer].flag.activity=activity;
  673.       if (activity==0)
  674.         (*network).neuron[neuron][layer].state=0;
  675.       if (bias==0)
  676.         (*network).neuron[neuron][layer].bias=0;
  677.     }    
  678. }
  679.  
  680.  
  681. void init_var_network(NETWORKS  *network,
  682.                         float err_threshold,
  683.                         float beta,
  684.                         float coefficient,
  685.                         float coef_out,
  686.                         float high_threshold,
  687.                         float low_threshold,
  688.                         float weight_threshold,
  689.                         float threshold,
  690.                         float noise,
  691.                         float high_state,
  692.                         float low_state,
  693.                         float t_max,
  694.                         float t_min,
  695.                         float cte)
  696. {
  697.   (*network).err_threshold=err_threshold*(*network).nb_n_layer[(*network).layer_order[(*network).nb_levels]];
  698.   (*network).beta=beta;
  699.   (*network).coefficient=coefficient;
  700.   (*network).coef_out=coef_out;
  701.   (*network).high_threshold=threshold+high_threshold/2/beta;
  702.   (*network).low_threshold=threshold+low_threshold/2/beta;
  703.   (*network).weight_threshold=weight_threshold;
  704.   (*network).threshold=threshold;
  705.   (*network).noise=noise;
  706.   (*network).high_state=high_state;
  707.   (*network).low_state=low_state;
  708.  
  709.   (*network).t_tempering_max=t_max;
  710.   (*network).t_tempering_min=t_min;
  711.   (*network).cte_tempering=cte;
  712.   (*network).energy=0;
  713. }
  714.  
  715. /* ------------------------------------------------------------ */
  716. /*                       infos                                  */
  717. /* ------------------------------------------------------------ */
  718.  
  719.  
  720. float compare_output(NETWORKS  *network,float output[])
  721. {       /* compare the output to the one expected */
  722.   int neuron,
  723.       layer=(*network).layer_order[(*network).nb_levels];
  724.   float err_tot=0,
  725.         error;
  726.  
  727.   for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  728.   {
  729.     error=(*network).neuron[neuron][layer].state-output[neuron];
  730.     err_tot+=0.5*error*error;
  731.   }
  732.   return(err_tot);
  733. }
  734.  
  735. float learn_verify(NETWORKS  *network,int list_prototypes[],int size_list,float inputs[],float outputs[])
  736. {       /* verify the learning for each prototype */
  737.   int k,j,NCin,NCout;
  738.   float err_max=0,err;
  739.   float input[NB_N_LAYER_MAXI],
  740.         output[NB_N_LAYER_MAXI];
  741.         
  742.                 /* nb of neurons in the 1st and last level */
  743.   NCin=(*network).nb_n_layer[(*network).layer_order[0]];
  744.   NCout=(*network).nb_n_layer[(*network).layer_order[(*network).nb_levels]];
  745.  
  746.   for (k=0; k<=size_list; k++)
  747.   {
  748.   for (j=0; j<=NCin; j++)
  749.   input[j]=inputs[list_prototypes[k]*(NCin+1)+j];
  750.   for (j=0; j<=NCout; j++)
  751.   output[j]=outputs[list_prototypes[k]*(NCout+1)+j];
  752.  
  753.   network_state(network,input);
  754.   err=compare_output(network,output);
  755.   printf("\nFinal error lot %2i : %4.2f (%%)",k,err/NCout*100);
  756.   if (err_max<err) err_max=err;
  757.   }
  758.   return(err_max);
  759. }
  760.  
  761. float sqr_sum(NETWORKS  *network)      /* sends back the sum(sqr(links)) */
  762. {
  763.   int neuron,layer,n,level,layer_1;
  764.   float sum2=0;
  765.  
  766.   for (layer=0; layer<=(*network).nb_layers; layer++)
  767.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  768.     {
  769.       sum2+=sqr((*network).neuron[neuron][layer].bias);
  770.       for (n=0; n<=(*network).nb_n_layer[layer]; n++)
  771.         sum2+=sqr((*network).neuron[neuron][layer].intra[n]);  
  772.     }
  773.   for (level=1; level<=(*network).nb_levels; level++)
  774.   {
  775.     layer=(*network).layer_order[level];
  776.     layer_1=(*network).layer_order[level-1];
  777.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  778.       for (n=0; n<=(*network).nb_n_layer[layer_1]; n++)
  779.         sum2+=sqr((*network).inter[level-1][n][neuron]);
  780.   }
  781.   return(sum2);   
  782. }
  783.  
  784.  
  785. void print_network(NETWORKS  *network)
  786. {
  787.   int neuron,level,layer;
  788.   float pot,state,loc_err,bias;
  789.   
  790.   printf("\nNetwork state:  sum, state, loc_err, bias");
  791.   for (level=0 ;level<=(*network).nb_levels; level++)
  792.   {
  793.     layer=(*network).layer_order[level];
  794.     printf("\n----------------------------------------------------\n");
  795.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  796.     {
  797.       pot=(*network).neuron[neuron][layer].sum;
  798.       printf(" %4.2f ",pot);
  799.     }
  800.     printf("\n");
  801.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  802.     {
  803.       state=(*network).neuron[neuron][layer].state;  
  804.       printf(" %4.2f ",state);
  805.     }
  806.     printf("\n");
  807.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  808.     {
  809.       loc_err=(*network).neuron[neuron][layer].loc_err;  
  810.       printf(" %4.2f ",loc_err);
  811.     }
  812.     printf("\n");
  813.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  814.     {
  815.       bias=(*network).neuron[neuron][layer].bias;  
  816.       printf(" %4.2f ",bias);
  817.     }
  818.   }
  819.   printf("\n----------------------------------------------------\n\n");
  820.   printf("\n <RETURN>");
  821.   getchar();
  822. } 
  823.  
  824. void info_struct_network(NETWORKS  *network)
  825. {
  826.   int i;
  827.  
  828.   printf("\n----------------- INFO STRUCTURE NETWORK -------------------\n\n");
  829.   printf("Memory size: %7.1f o\n",(float)sizeof(NETWORKS));
  830.   printf("Number of layers: %i\n",(*network).nb_layers+1);
  831.   printf("Number of levels: %i\n",(*network).nb_levels+1);
  832.   printf("\n");
  833.  
  834.   for (i=0; i<=(*network).nb_layers; i++)
  835.   {
  836.     printf("  Layer %2i, %3i neurons. Model ",i,(*network).nb_n_layer[i]+1);
  837.     if ((*network).flag[i].interconnection)
  838.       printf("Hopfield.\n");
  839.     else
  840.       printf("Perceptron.\n");
  841.   }    
  842.   printf("\n");
  843.   printf("The levels of the network are the layers:\n   -> ");
  844.   for (i=0; i<=(*network).nb_levels; i++)
  845.     printf(" %i ",(*network).layer_order[i]);     
  846.   printf("\n\n");
  847.   
  848.   printf("\n <RETURN>");
  849.   getchar();
  850. }
  851.  
  852. void info_vars_network(NETWORKS *network)
  853. {
  854.   float s,
  855.         s1=0,
  856.         s2=0,
  857.         sqr1=0,
  858.         sqr2=0;
  859.   int i=0,j=0,neuron,layer,n,level,layer_1;
  860.   
  861.   printf("\n---------------- INFO VARIABLES NETWORK -------------------\n");
  862.   printf("\n");
  863.   printf("Temperature: %5.2f\n",1/(*network).beta);
  864.   printf("Learning improving coefficient: %4.2f\n",(*network).coefficient);
  865.   printf("Threshold error on learning end: %4.3f (%3.1f %%)\n",(*network).err_threshold,
  866.   (*network).err_threshold/(*network).nb_n_layer[(*network).layer_order[(*network).nb_levels]]*100);
  867.   printf("High neuron state: %4.2f\n",(*network).high_state);
  868.   printf("Low neuron state : %4.2f\n",(*network).low_state);
  869.   printf("High threshold neuron potential: %4.2f\n",(*network).high_threshold);
  870.   printf("Low threshold neuron potential : %4.2f\n",(*network).low_threshold);
  871.   printf("Link threshold          : %4.2f\n",(*network).weight_threshold);
  872.   printf("Bascule neuron threshold: %4.2f\n",(*network).threshold);
  873.  
  874.   printf("Mean intra-layer link (Hopfield):");
  875.   for (layer=0; layer<=(*network).nb_layers; layer++)
  876.     for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  877.     {
  878.       s=(*network).neuron[neuron][layer].bias;
  879.       s1+=s;
  880.       sqr1+=sqr(s);
  881.       i++;
  882.       if ((*network).flag[layer].interconnection)
  883.         for (n=0; n<=(*network).nb_n_layer[layer]; n++)
  884.         {
  885.           s=(*network).neuron[neuron][layer].intra[n];
  886.           s1+=s;
  887.           sqr1+=sqr(s);
  888.           i++;
  889.         }
  890.     }
  891.   printf(" %5.3f\n\n",s1/i);
  892.  
  893.   if ((*network).nb_levels>0)
  894.   {
  895.     printf("Mean inter-layer link (Perceptron):");
  896.     for (level=1; level<=(*network).nb_levels; level++)
  897.     {
  898.       layer=(*network).layer_order[level];
  899.       layer_1=(*network).layer_order[level-1];
  900.       for (neuron=0; neuron<=(*network).nb_n_layer[layer]; neuron++)
  901.         for (n=0; n<=(*network).nb_n_layer[layer_1]; n++)
  902.         {
  903.           s=(*network).inter[level-1][n][neuron];
  904.           s2+=s;
  905.           sqr2+=sqr(s);
  906.           j++;
  907.         }
  908.     }
  909.     printf("%5.3f\n\n",s2/j);
  910.   }
  911.   printf("Mean global link: %5.3f\n",(s1+s2)/(i+j));
  912.   printf("Sum of intra-layer link square: %5.3f\n",sqr1);
  913.   printf("Sum of inter-layer link square: %5.3f\n",sqr2);
  914.   printf("\n");
  915.   printf("Network energy: %5.3f\n",(*network).energy);
  916.   printf("\n\n");
  917.  
  918.   printf("\n <RETURN>");
  919.   getchar();
  920. }
  921.  
  922. /* ------------------------------------------------------------ */
  923. /*                      END of module                           */
  924. /* ------------------------------------------------------------ */
  925.